{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/TechnoDexx/DataScience/blob/main/%D0%9F%D0%BE%D0%B3%D1%80%D1%83%D0%B6%D0%B5%D0%BD%D0%B8%D0%B5_%D0%B2_DS%2C_%D0%B4%D0%B5%D0%BD%D1%8C_2_%D1%80%D0%B5%D1%88%D0%B5%D0%BD%D0%B8%D0%B5_%D0%94%D0%97_%D0%9B%D0%B5%D0%B1%D0%B5%D0%B4%D0%B5%D0%B2%D0%BE%D0%B9_%D0%94%D0%B0%D1%80%D1%8C%D0%B8.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "import numpy as np\n",
        "\n",
        "# считываем данные по ссылке\n",
        "data = pd.read_csv('https://raw.githubusercontent.com/MariaZharova/3-day-intensive/main/Mall_Customers.csv', sep = ',')"
      ],
      "metadata": {
        "id": "0y1EPDTMOWn6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# библиотеки для машинного обучения\n",
        "import sklearn\n",
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.model_selection import cross_val_score\n",
        "from sklearn.metrics import accuracy_score\n",
        "from sklearn import metrics\n",
        "\n",
        "# сразу сделаем небольшое преобразование - переведём пол из строк в числа\n",
        "data.Genre = data.Genre.apply(lambda x: 0 if x == 'Male' else 1)\n",
        "\n",
        "# выделим для удобства таргет и признаки\n",
        "X = data.drop('Score', axis = 1) # характеристики\n",
        "y = data.Score # таргеты (правильные ответы)\n",
        "\n",
        "# делим на данные для обучения и для теста\n",
        "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)"
      ],
      "metadata": {
        "id": "Nw-8g0gdWzMV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aKcmeGTSRJ7w"
      },
      "source": [
        "### ⛳ Домашнее задание\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SlaQhMUWb0gN"
      },
      "source": [
        "✅ Задание 1:  Назовите число колонок в файле"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print('Число колонок в файле =', data.shape[1])"
      ],
      "metadata": {
        "id": "Kz6ATRbg2WNn",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "57fcf0d6-6cd6-4df2-bf50-f653d7c936af"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Число колонок в файле = 5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "✅ Задание 2:  Назовите имя самой первой колонки"
      ],
      "metadata": {
        "id": "ob2Q8G0R2fLv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print('Имя самой первой колонки:', data.columns[0])"
      ],
      "metadata": {
        "id": "-AvflHRs2fe-",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "aa0c3530-f5f6-4b21-9d78-48556ee89e7e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Имя самой первой колонки: CustomerID\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "✅ Задание 3:  Найдите самую масимальную оценку от пользователя"
      ],
      "metadata": {
        "id": "yf0lGLHk2fss"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print('Самая масимальная оценка от пользователя =', data.Score.max())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f6c99a94-40e5-4634-e618-30b4e71d1a52",
        "id": "4jB5IYhfR_l1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Самая масимальная оценка от пользователя = 99\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "✅ Задание 4*: Проверьте, есть ли в данных дубликаты, в ответ напишите \"да\" или \"нет\"\n",
        "\n",
        "*Подсказка: попробуйте использовать метод drop_duplicates"
      ],
      "metadata": {
        "id": "Wi0ujbma2gMh"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "data_new = data.copy()\n",
        "data_new.drop_duplicates()\n",
        "print('Нет') if data.shape[0] == data_new.shape[0] else print('Да')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8ICQAlCUpV0d",
        "outputId": "949ff6e4-ab68-4ace-a4e7-a40f331a812d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Нет\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ihjeCbQ3dkAV"
      },
      "source": [
        "✅ Задание 5: Попробуйте найти в документации ещё какие-нибудь модели из sklearn, и по аналогии с последней ячейкой обучить их на наших данных. Количество моделей неограничено:) В качестве итога можете посчитать метрику score и выбрать наилучшую модель.\n",
        "\n",
        "Подсказка: можно поменять только название модели в первой строке, весь остальной код будет аналогичным."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "myjYdMzDKvK6"
      },
      "source": [
        "- Цель: написать алгоритм (модель машинного обучения), который бы как можно точнее предсказывал Target, видя только столбцы-характеристики. Например, очень популярный подход - подобрать такие коэффициенты $a_1, a_2, ..., a_N$, чтобы сумма $x_1\\cdot a_1 + ... + x_N\\cdot a_N$ максимально точно приближала истинный ответ Target (пытаемся вывести закономерности, понять, какие столбцы влияют на итоговый ответ больше всего)."
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 1 вариант кода с другой моделью: применяем \"Случайный лес\" - RandomForestRegressor\n",
        "# RandomForestRegressor - тип метода ансамблевого обучения для регрессии\n",
        "# RandomForestRegressor работает путем построения нескольких деревьев решений во время обучения и вывода среднего прогноза для отдельных деревьев\n",
        "\n",
        "from sklearn.ensemble import RandomForestRegressor\n",
        "\n",
        "reg = RandomForestRegressor() # 1\n",
        "reg.fit(X_train, y_train) # 2\n",
        "y_pred = reg.predict(X_test) # 3\n",
        "rmse = (np.sqrt(metrics.mean_squared_error(y_test, y_pred))) # 4\n",
        "\n",
        "print(f\"The model performance for testing set\") # красивая печать на экран :)\n",
        "print(f\"--------------------------------------\")\n",
        "print(f\"Root Mean Squared Error: {rmse}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2b823c0d-bda4-42cd-b7a0-1c8088b7cdad",
        "id": "TTqQxXyaG0x5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The model performance for testing set\n",
            "--------------------------------------\n",
            "Root Mean Squared Error: 20.043671195666725\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 2 вариант кода с другой моделью: применяем Метод опорных векторов - SVR\n",
        "# SVR - тип алгоритма регрессии, который использует машины опорных векторов для выполнения задач регрессии\n",
        "# SVR работает путем поиска гиперплоскости, которая максимизирует разницу между прогнозируемыми значениями и фактическими значениями\n",
        "\n",
        "from sklearn.svm import SVR\n",
        "\n",
        "reg = SVR() # 1\n",
        "reg.fit(X_train, y_train) # 2\n",
        "y_pred = reg.predict(X_test) # 3\n",
        "rmse = (np.sqrt(metrics.mean_squared_error(y_test, y_pred))) # 4\n",
        "\n",
        "print(f\"The model performance for testing set\") # красивая печать на экран :)\n",
        "print(f\"--------------------------------------\")\n",
        "print(f\"Root Mean Squared Error: {rmse}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "da96e96a-ebba-4314-c5cf-3c97a2db8dee",
        "id": "4LZ3BWmhJxdj"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The model performance for testing set\n",
            "--------------------------------------\n",
            "Root Mean Squared Error: 24.51660326402299\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 3 вариант кода с другой моделью: применяем Метод K-ближайших соседей - KNeighborsRegressor\n",
        "# KNeighborsRegressor - тип алгоритма обучения на основе экземпляров\n",
        "# KNeighborsRegressor работает путем поиска k-ближайших соседей к заданной точке данных\n",
        "# и использования их среднего значения в качестве прогнозируемого значения для точки данных\n",
        "\n",
        "from sklearn.neighbors import KNeighborsRegressor\n",
        "\n",
        "reg = KNeighborsRegressor() # 1\n",
        "reg.fit(X_train, y_train) # 2\n",
        "y_pred = reg.predict(X_test) # 3\n",
        "rmse = (np.sqrt(metrics.mean_squared_error(y_test, y_pred))) # 4\n",
        "\n",
        "print(f\"The model performance for testing set\") # красивая печать на экран :)\n",
        "print(f\"--------------------------------------\")\n",
        "print(f\"Root Mean Squared Error: {rmse}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2e55686e-24eb-4827-bdc6-a5b9a85a7532",
        "id": "jR1xZTWuLpxT"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The model performance for testing set\n",
            "--------------------------------------\n",
            "Root Mean Squared Error: 19.543029447861965\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "k2Fc7paBfexg"
      },
      "source": [
        "# 🔎 Выводы:\n",
        "Если показатель Root Mean Squared Error (RMSE) меньше, это означает, что модель работает лучше и точнее. RMSE является метрикой, которая показывает разность между предсказанными и наблюдаемыми значениями в модели.\n",
        "\n",
        "Модель линейной регрессии - LinearRegression даёт Среднеквадратичную ошибку, т.е. Root Mean Squared Error = 22.46448986768789\n",
        "\n",
        "Модель \"Случайный лес\" - RandomForestRegressor даёт Среднеквадратичную ошибку, т.е. Root Mean Squared Error = 20.464614154681733\n",
        "\n",
        "Метод опорных векторов - SVR даёт Среднеквадратичную ошибку, т.е. Root Mean Squared Error = 24.51660326402299\n",
        "\n",
        "Метод K-ближайших соседей - KNeighborsRegressor даёт Среднеквадратичную ошибку, т.е. Root Mean Squared Error = 19.543029447861965\n",
        "\n",
        "Таким образом, Метод K-ближайших соседей - KNeighborsRegressor даёт наименьшее значение из всех опробованных методов, т.е. он показал лучший результат.\n",
        "Более низкое значение RMSE указывает на то, что модель имеет меньшую среднеквадратичную ошибку и лучше соответствует данным."
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Исходный вариант кода от преподавателя: применяется модель линейной регрессии - LinearRegression\n",
        "from sklearn.linear_model import LinearRegression\n",
        "\n",
        "reg = LinearRegression() # 1\n",
        "reg.fit(X_train, y_train) # 2\n",
        "y_pred = reg.predict(X_test) # 3\n",
        "rmse = (np.sqrt(metrics.mean_squared_error(y_test, y_pred))) # 4\n",
        "\n",
        "print(f\"The model performance for testing set\") # красивая печать на экран :)\n",
        "print(f\"--------------------------------------\")\n",
        "print(f\"Root Mean Squared Error: {rmse}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1fmZF19tCHGY",
        "outputId": "e352229a-1677-4120-c7d5-249b0ff8632b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The model performance for testing set\n",
            "--------------------------------------\n",
            "Root Mean Squared Error: 22.46448986768789\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7muXgYCQe3on"
      },
      "source": [
        "✅ Задание 6*: Попробуйте сделать предсказание на своих собственных данных. Можете воспользоваться приведённым шаблоном"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "# генерируем собственные случайные данные для 10 покупателей: ID (в диапазоне от 1 до 1 млн.)\n",
        "# пола (0 - жен, 1 - муж), возраста (от 18 до 100 лет включительно) и суммы покупки (от 1 до 100 тыс. рублей)\n",
        "\n",
        "id_list = np.random.randint(1, 1_000_001, size=10)\n",
        "gender_list = np.random.randint(0, 2, size=10)\n",
        "age_list = np.random.randint(18, 101, size=10)\n",
        "purchase_list = np.random.randint(1, 100_001, size=10)\n",
        "\n",
        "# объединяем сгенерированные списки в массив numpy\n",
        "data = np.column_stack((id_list, gender_list, age_list, purchase_list))\n",
        "\n",
        "print(data)\n",
        "print()\n",
        "\n",
        "# создаем модель и загружаем в нее веса\n",
        "reg = LinearRegression()\n",
        "reg.fit(X_train, y_train)\n",
        "\n",
        "# делаем предсказания на своих данных\n",
        "data_to_predict = np.array([1, 0, 20, 50_000]).reshape(1, -1)\n",
        "print(\"Предсказание на собственных данных:\", reg.predict(data_to_predict))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1qPdOI1LQ6wu",
        "outputId": "b6ff2f1e-6788-42b2-a08e-f3303c167af4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[587134      1     44  29568]\n",
            " [316213      1     94  74468]\n",
            " [ 36086      1     45  29071]\n",
            " [ 66474      1     39   1997]\n",
            " [389535      1     76  65931]\n",
            " [849136      1     93  66758]\n",
            " [503628      1     33  78260]\n",
            " [176858      1     82  39292]\n",
            " [117682      1     63  71698]\n",
            " [442006      0     33  42902]]\n",
            "\n",
            "Предсказание на собственных данных: [-10051.30536044]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/sklearn/base.py:439: UserWarning: X does not have valid feature names, but LinearRegression was fitted with feature names\n",
            "  warnings.warn(\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "🌟 PS: Можете подумать, какая колонка является неинформативной с точки зрения обучения (соответственно, её можно удалить:))\n",
        "\n"
      ],
      "metadata": {
        "id": "PNwIroOH86R7"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 🌟 Мой ответ: **неинформативной с точки зрения обучения является колонка CustomerID или ID**"
      ],
      "metadata": {
        "id": "O2AyHtT8p6K8"
      }
    }
  ],
  "metadata": {
    "colab": {
      "provenance": [],
      "include_colab_link": true
    },
    "gpuClass": "standard",
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.6.1"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}